home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / sealink.arc / SEALINK.C < prev    next >
Encoding:
C/C++ Source or Header  |  1986-09-05  |  19.6 KB  |  543 lines
  1. /*  SEAlink - Sliding window file transfer protocol
  2.  
  3.     Version 1.00, created on 09/04/86 at 14:37:58
  4.  
  5. (C) COPYRIGHT 1986 by System Enhancement Associates; ALL RIGHTS RESERVED
  6.  
  7.     By:  Thom Henderson
  8.  
  9.     Description:
  10.  
  11.          This file contains a set of routines to illustrate the SEAlink
  12.          sliding window file transfer protocol.  SEAlink is fully backward
  13.          compatible to XMODEM, and can be easily adapted to most XMODEM
  14.          variants.
  15.  
  16.          The intent of SEAlink is to provide a file transfer protocol that
  17.          does not suffer from propagation delays, such as are introduced
  18.          by satellite relays or packet switched networks.
  19.  
  20.     Instructions:
  21.  
  22.          Two routines are provided to implement SEAlink file transfers.
  23.  
  24.          int xmtfile(name)             /+ transmit a file +/
  25.          char *name;                   /+ name of file to transmit +/
  26.  
  27.          This routine is used to send a file.  One file is sent at a time.
  28.          If the name is blank (name is null or *name points to a null),
  29.          then only an end of transmission marker is sent.
  30.  
  31.          This routine returns a one if the file is successfully
  32.          transmitted, or a zero if a fatal error occurs.
  33.  
  34.          char *rcvfile(name)           /+ receive a file +/
  35.          char *name;                   /+ name of file (optional) +/
  36.  
  37.          This routine is used to receive a file.  One file is received.
  38.          The name, if given, takes precedence and will be the name of
  39.          the resulting file.  If the name is blank (name is null or *name
  40.          points to a null), then the name given by the transmitter is used.
  41.          If the transmitter does not give a name, then a default name is
  42.          used.
  43.  
  44.          This routine returns a pointer to the name of the file that
  45.          was received.  If the file transfer is not successful, then
  46.          a null pointer is returned.
  47.  
  48.          The pointer returned by rcvfile() points to a static data buffer.
  49.          This does not have to be freed (and should not be), but it will
  50.          be overwritten the next time rcvfile() is called.
  51.  
  52.          The rcvfile() function works on a temporary file whose name is
  53.          the same as the final file, but with a dash ("-") added at the
  54.          beginning.  If a file transfer is aborted, then this temporary
  55.          file will be retained.  An aborted file transfer will not harm
  56.          a pre-existing file of the same name.
  57.  
  58.     Programming notes:
  59.  
  60.          These routines can be used for either single or multiple file
  61.          transfers.
  62.  
  63.          To send multiple files, send each one one at a time until either
  64.          a transmit fails or all files are sent.  If all files are sent,
  65.          then signal the end by calling xmtfile() with a null pointer.
  66.  
  67.          To receive multiple files, call rcvfile() repeatedly until it
  68.          returns a null pointer.
  69.  
  70.          These routines pass a "block zero", which contains information
  71.          about the original file name, size, and date/time of last
  72.          modification.  If you cannot implement block zero, then you can
  73.          leave it out.  If you cannot set any given field in block zero
  74.          when transmitting, then you should leave it set to zeros.  If you
  75.          cannot use any given field of block zero when receiving, then
  76.          you should ignore it.
  77.  
  78.          These routines are fully compatible with XMODEM, including the
  79.          original checksum method and later CRC adaptations.  It can be
  80.          easily adapted to Modem7 protocol by adding a Modem7 filename
  81.          transfer shell, though we do not recommend it.  The underlying
  82.          logic, of course, can be adapted to almost any variant of XMODEM.
  83.  
  84.     License:
  85.  
  86.          You are granted a license to use this code in your programs, and
  87.          to adapt it to your particular situation and needs, subject only
  88.          to the following conditions:
  89.  
  90.          1)   You must refer to it as the SEAlink protocol, and you must
  91.               give credit to System Enhancement Associates.
  92.  
  93.          2)   If you modify it in such a way that your version cannot
  94.               converse with the original code as supplied by us, then
  95.               you should refer to it as "SEAlink derived", or as a
  96.               "variation of SEAlink", or words to that effect.
  97.  
  98.          In short, we're not asking for any money, but we'd like to
  99.          get some credit for our work.
  100.  
  101.     Language:
  102.          Computer Innovations Optimizing C86
  103. */
  104. #include <stdio.h>
  105. #include <time.h>
  106.  
  107. struct zeros                           /* block zero data structure */
  108. {   long flen;                         /* file length */
  109.     long fstamp;                       /* file date/time stamp */
  110.     char fnam[17];                     /* original file name */
  111.     char prog[15];                     /* sending program name */
  112.     char fill[88];                     /* reserved for future use */
  113. }   ;
  114.  
  115. #define ACK 0x06
  116. #define NAK 0x15
  117. #define SOH 0x01
  118. #define EOT 0x04
  119.  
  120. static int outblk;                     /* number of next block to send */
  121. static int ackblk;                     /* number of last block ACKed */
  122. static int blksnt;                     /* number of last block sent */
  123. static int slide;                      /* true if sliding window */
  124. static int ackst;                      /* ACK/NAK state */
  125. static int numnak;                     /* number of sequential NAKs */
  126. static int chktec;                     /* check type, 1=CRC, 0=checksum */
  127.  
  128. char *progname = "Your name here";     /* name of sending program */
  129.  
  130. /*  File transmitter logic */
  131.  
  132. int xmtfile(name)                      /* transmit a file */
  133. char *name;                            /* name of file to send */
  134. {
  135.     FILE *f, *fopen();                 /* file to send */
  136.     long t1, timerset();               /* timers */
  137.     int c;                             /* one byte of data */
  138.     int endblk;                        /* block number of EOT */
  139.     struct filstat fst;                /* data about file */
  140.     struct zeros zero;                 /* block zero data */
  141.  
  142.     if(name && *name)                  /* if sending a file */
  143.     {    if(!(f=fopen(name,"rb")))
  144.          {    printf("Can't read %s\n",name);
  145.               return 0;
  146.          }
  147.  
  148.          setmem(&zero,sizeof(zero),0); /* clear out data block */
  149.  
  150.          filestat(name,&fst);          /* get file statistics */
  151.          zero.flen = fst.fs_fsize;
  152.          zero.fstamp = fst.fs_abs;
  153.          strcpy(zero.fnam,fst.fs_fname);
  154.          strcpy(zero.prog,progname);
  155.  
  156.          endblk = ((zero.flen+127)/128) + 1;
  157.          printf("Ready to send %d blocks of %s\n",endblk-1,zero.fnam);
  158.     }
  159.     else endblk = 0;                   /* fake for no file */
  160.  
  161.     outblk = 1;                        /* set starting state */
  162.     ackblk = -1;
  163.     blksnt = slide = ackst = numnak = 0;
  164.     chktec = 2;                        /* undetermined */
  165.  
  166.     t1 = timerset(300);                /* time limit for first block */
  167.  
  168.     while(ackblk<endblk)               /* while not all there yet */
  169.     {    if(!carrier())
  170.          {    printf("\nLost carrier\n");
  171.               goto abort;
  172.          }
  173.          if(key_scan()!=EOF)
  174.          {    if((key_getc()&0xff)==27)
  175.               {    printf("\nAborted by operator\n");
  176.                    goto abort;
  177.               }
  178.          }
  179.          if(timeup(t1))
  180.          {    printf("\nFatal timeout\n");
  181.               goto abort;
  182.          }
  183.          if(outblk <= ackblk + (slide? 4 : 1))
  184.          {    if(outblk<endblk)
  185.               {    if(outblk>0)
  186.                         sendblk(f,outblk);
  187.                    else shipblk(&zero,0);
  188.                    printf("Sent block #%d  \r",outblk);
  189.               }
  190.               else if(outblk==endblk)
  191.               {    com_putc(EOT);
  192.                    printf("Sent EOT          \r");
  193.               }
  194.               outblk++;
  195.               t1 = timerset(100);      /* time limit between blocks */
  196.          }
  197.  
  198.          ackchk();
  199.          if(numnak>10)
  200.          {    printf("\nToo many errors\n");
  201.               goto abort;
  202.          }
  203.     }
  204.  
  205.     printf("End of file       \n");
  206.     if(endblk)
  207.          fclose(f);
  208.     return 1;                          /* exit with good status */
  209.  
  210. abort:
  211.     if(endblk)
  212.          fclose(f);
  213.     return 0;                          /* exit with bad status */
  214. }
  215.  
  216. /*  The various ACK/NAK states are:
  217.     0:   Ground state, ACK or NAK expected.
  218.     1:   ACK received
  219.     2:   NAK received
  220.     3:   ACK, block# received
  221.     4:   NAK, block# received
  222.     5:   Returning to ground state
  223. */
  224.  
  225. static ackchk()                        /* check for ACK or NAK */
  226. {
  227.     int c;                             /* one byte of data */
  228.     static int rawblk;                 /* raw block number */
  229.  
  230.     while((c=com_getc(0))!=EOF)
  231.     {    if(ackst==3 || ackst==4)
  232.          {    slide = 0;               /* assume this will fail */
  233.               if(rawblk == c^0xff)     /* see if we believe the number */
  234.               {    rawblk = outblk - ((outblk-rawblk)&0xff);
  235.                    if(rawblk<=outblk && rawblk>outblk-20)
  236.                    {    slide = 1;     /* we have sliding window! */
  237.                         if(ackst==3)
  238.                              ackblk = ackblk>rawblk? ackblk : rawblk;
  239.                         else
  240.                         {    outblk = rawblk<0? 0 : rawblk;
  241.                              com_dump();    /* purge pending output */
  242.                         }
  243.                         printf("\r%s %d == ",ackst==3? "ACK":"NAK",rawblk);
  244.                    }
  245.               }
  246.               ackst = 5;               /* return to ground state */
  247.          }
  248.  
  249.          if(ackst==1 || ackst==2)
  250.          {    rawblk = c;
  251.               ackst += 2;
  252.          }
  253.  
  254.          if(!slide || ackst==0)
  255.          {    if(c==ACK)
  256.               {    if(!slide)
  257.                    {    ackblk++;
  258.                         printf("\rACK %d -- ",ackblk);
  259.                    }
  260.                    ackst = 1;
  261.                    numnak = 0;
  262.               }
  263.  
  264.               else if(c=='C' || c==NAK)
  265.               {    if(chktec>1)        /* if method not determined yet */
  266.                         chktec = (c=='C');  /* then do what rcver wants */
  267.  
  268.                    if(!slide)
  269.                    {    outblk = ackblk+1;
  270.                         printf("\rNAK %d -- ",ackblk+1);
  271.                    }
  272.                    ackst = 2;
  273.                    numnak++;
  274.               }
  275.          }
  276.  
  277.          if(ackst==5)
  278.               ackst = 0;
  279.     }
  280. }
  281.  
  282. static sendblk(f,blknum)               /* send one block */
  283. FILE *f;                               /* file to read from */
  284. int blknum;                            /* block to send */
  285. {
  286.     long blkloc;                       /* address of start of block */
  287.     char buf[128];                     /* one block of data */
  288.  
  289.     if(blknum != blksnt+1)             /* if jumping */
  290.     {    blkloc = (long)(blknum-1) * 128L;
  291.          fseek(f,blkloc,0);            /* move where to */
  292.     }
  293.     blksnt = blknum;
  294.  
  295.     setmem(buf,128,26);                /* fill buffer with control Zs */
  296.     fread(buf,1,128,f);                /* read in some data */
  297.     shipblk(buf,blknum);               /* pump it out the comm port */
  298. }
  299.  
  300. static int shipblk(blk,blknum)         /* physically ship a block */
  301. char *blk;                             /* data to be shipped */
  302. int blknum;                            /* number of block */
  303. {
  304.     char *b = blk;                     /* data pointer */
  305.     int crc = 0;                       /* CRC check value */
  306.     int n;                             /* index */
  307.  
  308.     com_putc(SOH);                     /* block header */
  309.     com_putc(blknum);                  /* block number */
  310.     com_putc(blknum^0xff);             /* block number check value */
  311.  
  312.     for(n=0; n<128; n++)               /* ship the data */
  313.     {    if(chktec)
  314.               crc = crc_update(crc,*b);
  315.          else crc += *b;
  316.          com_putc(*b++);
  317.     }
  318.  
  319.     if(chktec)                         /* send proper check value */
  320.     {    crc = crc_finish(crc);
  321.          com_putc(crc>>8);
  322.          com_putc(crc&0xff);
  323.     }
  324.     else com_putc(crc);
  325.  
  326.     return 1;
  327. }
  328.  
  329. /*  File receiver logic */
  330.  
  331. char *rcvfile(name)                    /* receive file */
  332. char *name;                            /* name of file */
  333. {
  334.     int c;                             /* received character */
  335.     int tries;                         /* retry counter */
  336.     long t1, timerset();               /* timer */
  337.     int blknum;                        /* desired block number */
  338.     int inblk;                         /* this block number */
  339.     FILE *f, *fopen();                 /* file, opener */
  340.     char buf[128];                     /* data buffer */
  341.     char tmpname[100];                 /* name of temporary file */
  342.     static char outname[100];          /* name of final file */
  343.     struct zeros zero;                 /* file header data storage */
  344.     int endblk;                        /* block number of EOT, if known */
  345.     long left;                         /* bytes left to output */
  346.     int n;                             /* index */
  347.     char *stat = "Init";               /* receive block status */
  348.  
  349.     if(name && *name)                  /* figure out a name to use */
  350.          strcpy(outname,name);
  351.     else strcpy(outname,"UNKNOWN.$$$");
  352.     strcpy(tmpname,"-"); strcat(tmpname,outname);
  353.  
  354.     if(!(f=fopen(tmpname,"wb")))       /* open output file */
  355.     {    printf("Cannot create %s",tmpname);
  356.          return NULL;
  357.     }
  358.  
  359.     blknum = 1;                        /* start with block #1 */
  360.     tries = -10;                       /* kludge for first time around */
  361.     chktec = 1;                        /* try for CRC error checking */
  362.     endblk = 0;                        /* we don't know the size yet */
  363.     setmem(&zero,sizeof(zero),0);      /* or much of anything else */
  364.  
  365. nakblock:                              /* we got a bad block */
  366.     printf("NAK block %d %-4s\r",blknum,stat);
  367.     if(++tries>10)
  368.     {    printf("\nToo many errors\n");
  369.          goto abort;
  370.     }
  371.     if(tries==0)                       /* if CRC isn't going */
  372.          chktec = 0;                   /* then give checksum a try */
  373.  
  374.     sendack(0,blknum);                 /* send the NAK */
  375.     goto nextblock;
  376.  
  377. ackblock:                              /* we got a good block */
  378.     printf("ACK block %d %-4s\r",blknum-1,stat);
  379.  
  380. nextblock:                             /* start of "get a block" */
  381.     stat = "";
  382.     if(!carrier())
  383.     {    printf("\nLost carrier\n");
  384.          goto abort;
  385.     }
  386.     if(key_scan()!=EOF)
  387.     {    if((key_getc()&0xff)==27)
  388.          {    printf("\nAborted by operator\n");
  389.               goto abort;
  390.          }
  391.     }
  392.     t1 = timerset(50);                 /* timer to start of block */
  393.     while(!timeup(t1))
  394.     {    c = com_getc(0);
  395.          if(c==EOT)
  396.          {    if(!endblk || endblk==blknum)
  397.                    goto endrcv;
  398.          }
  399.          else if(c==SOH)
  400.          {    inblk = com_getc(5);
  401.               if(com_getc(5) == (inblk^0xff))
  402.                    goto blockstart;    /* we found a start */
  403.          }
  404.     }
  405.     stat = "Time";
  406.     goto nakblock;
  407.  
  408. blockstart:                            /* start of block detected */
  409.     c = blknum&0xff;
  410.     if(inblk==c)                       /* if this is the one we want */
  411.     {    if(getblock(buf))             /* else if we get it okay */
  412.          {    sendack(1,inblk);        /* ack the data */
  413.               for(n=0; n<128; n++)
  414.               {    if(endblk)          /* limit file size if known */
  415.                    {    if(!left)
  416.                              break;
  417.                         left--;
  418.                    }
  419.                    if(fputc(buf[n],f)==EOF)
  420.                    {    printf("\nWrite error (disk full?)\n");
  421.                         goto abort;
  422.                    }
  423.               }
  424.               tries = 0;               /* reset try count */
  425.               blknum++;                /* we want the next block */
  426.               goto ackblock;
  427.          }
  428.          else
  429.          {    stat = chktec? "CRC" : "Chk";
  430.               goto nakblock;           /* ask for a resend */
  431.          }
  432.     }
  433.     else if(inblk==0 && blknum==1)     /* else if this is the header */
  434.     {    if(getblock(&zero))
  435.          {    sendack(1,inblk);        /* ack the header */
  436.               if(!*name)               /* given name takes precedence */
  437.                    strcpy(outname,zero.fnam);
  438.               if(left=zero.flen)       /* length to transfer */
  439.                    endblk = (left+127)/128 + 1;
  440.  
  441.               printf("Receiving");
  442.               if(endblk)
  443.                    printf(" %d blocks of",endblk-1);
  444.               printf(" %s",outname);
  445.               if(*zero.prog)
  446.                    printf(" from %s",zero.prog);
  447.               printf("\n");
  448.               goto ackblock;
  449.          }
  450.          else
  451.          {    stat = chktec? "CRC" : "Chk";
  452.               goto nakblock;           /* bad header block */
  453.          }
  454.     }
  455.     else if(inblk<c || inblk>c+100)    /* else if resending what we have */
  456.     {    getblock(buf);                /* ignore it */
  457.          sendack(1,inblk);             /* but ack it */
  458.          stat = "Dup";
  459.          goto ackblock;
  460.     }
  461.     else                               /* else if running ahead */
  462.     {    printf("Future block     \r");
  463.          goto nextblock;
  464.     }
  465.  
  466. endrcv:
  467.     sendack(0,blknum);
  468.     printf("NAK EOT         \r");
  469.     if(com_getc(20)!=EOT)
  470.          goto nakblock;
  471.     sendack(1,blknum);
  472.     printf("ACK EOT\r");
  473.  
  474.     if(blknum>1)                       /* if we really got anything */
  475.     {    if(zero.fstamp)               /* set stamp, if known */
  476.               setstamp(f,zero.fstamp);
  477.          fclose(f);
  478.          unlink(outname);              /* rename temp to proper name */
  479.          rename(tmpname,outname);
  480.          return outname;               /* signal what file we got */
  481.     }
  482.     else                               /* else no real file */
  483.     {    fclose(f);
  484.          unlink(tmpname);              /* discard empty file */
  485.          return NULL;                  /* signal end of transfer */
  486.     }
  487.  
  488. abort:
  489.     fclose(f);
  490.     return NULL;
  491. }
  492.  
  493. static sendack(acknak,blknum)          /* send an ACK or a NAK */
  494. int acknak;                            /* 1=ACH, 0=NAK */
  495. int blknum;                            /* block number */
  496. {
  497.     if(acknak)                         /* send the right signal */
  498.          com_putc(ACK);
  499.     else if(chktec)
  500.          com_putc('C');
  501.     else com_putc(NAK);
  502.  
  503.     com_putc(blknum);                  /* block number */
  504.     com_putc(blknum^0xff);             /* block number check */
  505. }
  506.  
  507. static int getblock(buf)               /* read a block of data */
  508. char *buf;                             /* data buffer */
  509. {
  510.     int ourcrc = 0, hiscrc;            /* CRC check values */
  511.     int c;                             /* one byte of data */
  512.     int n;                             /* index */
  513.  
  514.     for(n=0; n<128; n++)
  515.     {    if((c=com_getc(5))==EOF)
  516.          {    printf("Short block     \r");
  517.               return 0;
  518.          }
  519.          if(chktec)
  520.               ourcrc = crc_update(ourcrc,c);
  521.          else ourcrc += c;
  522.          *buf++ = c;
  523.     }
  524.  
  525.     if(chktec)
  526.     {    ourcrc = crc_finish(ourcrc);
  527.          hiscrc = (com_getc(5)<<8) | com_getc(5);
  528.     }
  529.     else
  530.     {    ourcrc &= 0xff;
  531.          hiscrc = com_getc(5) & 0xff;
  532.     }
  533.  
  534.     if(ourcrc == hiscrc)
  535.          return 1;
  536.     else
  537.     {    if(chktec)
  538.               printf("Bad CRC         \r");
  539.          else printf("Bad Checksum    \r");
  540.          return 0;
  541.     }
  542. }
  543.